define("ace/mode/csound_preprocessor_highlight_rules", ["require", "exports", "module", "ace/lib/oop", "ace/mode/text_highlight_rules"], function (require, exports, module) {
    "use strict";

    var oop = require("../lib/oop");

    var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;

    var CsoundPreprocessorHighlightRules = function () {

        this.semicolonComments = {
            token: "comment.line.semicolon.csound",
            regex: ";.*$"
        };

        this.comments = [
            {
                token: "punctuation.definition.comment.begin.csound",
                regex: "/\\*",
                push: [
                    {
                        token: "punctuation.definition.comment.end.csound",
                        regex: "\\*/",
                        next: "pop"
                    }, {
                        defaultToken: "comment.block.csound"
                    }
                ]
            }, {
                token: "comment.line.double-slash.csound",
                regex: "//.*$"
            },
            this.semicolonComments
        ];

        this.macroUses = [
            {
                token: ["entity.name.function.preprocessor.csound", "punctuation.definition.macro-parameter-value-list.begin.csound"],
                regex: /(\$[A-Z_a-z]\w*\.?)(\()/,
                next: "macro parameter value list"
            }, {
                token: "entity.name.function.preprocessor.csound",
                regex: /\$[A-Z_a-z]\w*(?:\.|\b)/
            }
        ];

        this.numbers = [
            {
                token: "constant.numeric.float.csound",
                regex: /(?:\d+[Ee][+-]?\d+)|(?:\d+\.\d*|\d*\.\d+)(?:[Ee][+-]?\d+)?/
            }, {
                token: ["storage.type.number.csound", "constant.numeric.integer.hexadecimal.csound"],
                regex: /(0[Xx])([0-9A-Fa-f]+)/
            }, {
                token: "constant.numeric.integer.decimal.csound",
                regex: /\d+/
            }
        ];

        this.bracedStringContents = [
            {
                token: "constant.character.escape.csound",
                regex: /\\(?:[\\abnrt"]|[0-7]{1,3})/
            },
            {
                token: "constant.character.placeholder.csound",
                regex: /%[#0\- +]*\d*(?:\.\d+)?[diuoxXfFeEgGaAcs]/
            }, {
                token: "constant.character.escape.csound",
                regex: /%%/
            }
        ];

        this.quotedStringContents = [
            this.macroUses,
            this.bracedStringContents
        ];

        var start = [
            this.comments,

            {
                token: "keyword.preprocessor.csound",
                regex: /#(?:e(?:nd(?:if)?|lse)\b|##)|@@?[ \t]*\d+/
            }, {
                token: "keyword.preprocessor.csound",
                regex: /#include/,
                push: [
                    this.comments,
                    {
                        token: "string.csound",
                        regex: /([^ \t])(?:.*?\1)/,
                        next: "pop"
                    }
                ]
            }, {
                token: "keyword.preprocessor.csound",
                regex: /#[ \t]*define/,
                next: "define directive"
            }, {
                token: "keyword.preprocessor.csound",
                regex: /#(?:ifn?def|undef)\b/,
                next: "macro directive"
            },

            this.macroUses
        ];

        this.$rules = {
            "start": start,

            "define directive": [
                this.comments,
                {
                    token: "entity.name.function.preprocessor.csound",
                    regex: /[A-Z_a-z]\w*/
                }, {
                    token: "punctuation.definition.macro-parameter-name-list.begin.csound",
                    regex: /\(/,
                    next: "macro parameter name list"
                }, {
                    token: "punctuation.definition.macro.begin.csound",
                    regex: /#/,
                    next: "macro body"
                }
            ],
            "macro parameter name list": [
                {
                    token: "variable.parameter.preprocessor.csound",
                    regex: /[A-Z_a-z]\w*/
                }, {
                    token: "punctuation.definition.macro-parameter-name-list.end.csound",
                    regex: /\)/,
                    next: "define directive"
                }
            ],
            "macro body": [
                {
                    token: "constant.character.escape.csound",
                    regex: /\\#/
                }, {
                    token: "punctuation.definition.macro.end.csound",
                    regex: /#/,
                    next: "start"
                },
                start
            ],

            "macro directive": [
                this.comments,
                {
                    token: "entity.name.function.preprocessor.csound",
                    regex: /[A-Z_a-z]\w*/,
                    next: "start"
                }
            ],

            "macro parameter value list": [
                {
                    token: "punctuation.definition.macro-parameter-value-list.end.csound",
                    regex: /\)/,
                    next: "start"
                }, {
                    token: "punctuation.definition.string.begin.csound",
                    regex: /"/,
                    next: "macro parameter value quoted string"
                }, this.pushRule({
                    token: "punctuation.macro-parameter-value-parenthetical.begin.csound",
                    regex: /\(/,
                    next: "macro parameter value parenthetical"
                }), {
                    token: "punctuation.macro-parameter-value-separator.csound",
                    regex: "[#']"
                }
            ],
            "macro parameter value quoted string": [
                {
                    token: "constant.character.escape.csound",
                    regex: /\\[#'()]/
                }, {
                    token: "invalid.illegal.csound",
                    regex: /[#'()]/
                }, {
                    token: "punctuation.definition.string.end.csound",
                    regex: /"/,
                    next: "macro parameter value list"
                },
                this.quotedStringContents,
                {
                    defaultToken: "string.quoted.csound"
                }
            ],
            "macro parameter value parenthetical": [
                {
                    token: "constant.character.escape.csound",
                    regex: /\\\)/
                }, this.popRule({
                    token: "punctuation.macro-parameter-value-parenthetical.end.csound",
                    regex: /\)/
                }), this.pushRule({
                    token: "punctuation.macro-parameter-value-parenthetical.begin.csound",
                    regex: /\(/,
                    next: "macro parameter value parenthetical"
                }),
                start
            ]
        };
    };

    oop.inherits(CsoundPreprocessorHighlightRules, TextHighlightRules);

    (function () {

        this.pushRule = function (params) {
            return {
                regex: params.regex, onMatch: function (value, currentState, stack, line) {
                    if (stack.length === 0)
                        stack.push(currentState);
                    if (Array.isArray(params.next)) {
                        for (var i = 0; i < params.next.length; i++) {
                            stack.push(params.next[i]);
                        }
                    } else {
                        stack.push(params.next);
                    }
                    this.next = stack[stack.length - 1];
                    return params.token;
                },
                get next() {
                    return Array.isArray(params.next) ? params.next[params.next.length - 1] : params.next;
                },
                set next(next) {
                    if (Array.isArray(params.next)) {
                        var oldNext = params.next[params.next.length - 1];
                        var oldNextIndex = oldNext.length - 1;
                        var newNextIndex = next.length - 1;
                        if (newNextIndex > oldNextIndex) {
                            while (oldNextIndex >= 0 && newNextIndex >= 0) {
                                if (oldNext.charAt(oldNextIndex) !== next.charAt(newNextIndex)) {
                                    var prefix = next.substr(0, newNextIndex);
                                    for (var i = 0; i < params.next.length; i++) {
                                        params.next[i] = prefix + params.next[i];
                                    }
                                    break;
                                }
                                oldNextIndex--;
                                newNextIndex--;
                            }
                        }
                    } else {
                        params.next = next;
                    }
                },
                get token() {
                    return params.token;
                }
            };
        };

        this.popRule = function (params) {
            return {
                regex: params.regex, onMatch: function (value, currentState, stack, line) {
                    stack.pop();
                    if (params.next) {
                        stack.push(params.next);
                        this.next = stack[stack.length - 1];
                    } else {
                        this.next = stack.length > 1 ? stack[stack.length - 1] : stack.pop();
                    }
                    return params.token;
                }
            };
        };

    }).call(CsoundPreprocessorHighlightRules.prototype);

    exports.CsoundPreprocessorHighlightRules = CsoundPreprocessorHighlightRules;
});

define("ace/mode/csound_score_highlight_rules", ["require", "exports", "module", "ace/lib/oop", "ace/mode/csound_preprocessor_highlight_rules"], function (require, exports, module) {
    "use strict";

    var oop = require("../lib/oop");

    var CsoundPreprocessorHighlightRules = require("./csound_preprocessor_highlight_rules").CsoundPreprocessorHighlightRules;

    var CsoundScoreHighlightRules = function () {

        CsoundPreprocessorHighlightRules.call(this);

        this.quotedStringContents.push({
            token: "invalid.illegal.csound-score",
            regex: /[^"]*$/
        });

        var start = this.$rules.start;
        start.push(
            {
                token: "keyword.control.csound-score",
                regex: /[abCdefiqstvxy]/
            }, {
                token: "invalid.illegal.csound-score",
                regex: /w/
            }, {
                token: "constant.numeric.language.csound-score",
                regex: /z/
            }, {
                token: ["keyword.control.csound-score", "constant.numeric.integer.decimal.csound-score"],
                regex: /([nNpP][pP])(\d+)/
            }, {
                token: "keyword.other.csound-score",
                regex: /[mn]/,
                push: [
                    {
                        token: "empty",
                        regex: /$/,
                        next: "pop"
                    },
                    this.comments,
                    {
                        token: "entity.name.label.csound-score",
                        regex: /[A-Z_a-z]\w*/
                    }
                ]
            }, {
                token: "keyword.preprocessor.csound-score",
                regex: /r\b/,
                next: "repeat section"
            },

            this.numbers,

            {
                token: "keyword.operator.csound-score",
                regex: "[!+\\-*/^%&|<>#~.]"
            },

            this.pushRule({
                token: "punctuation.definition.string.begin.csound-score",
                regex: /"/,
                next: "quoted string"
            }),

            this.pushRule({
                token: "punctuation.braced-loop.begin.csound-score",
                regex: /{/,
                next: "loop after left brace"
            })
        );

        this.addRules({
            "repeat section": [
                {
                    token: "empty",
                    regex: /$/,
                    next: "start"
                },
                this.comments,
                {
                    token: "constant.numeric.integer.decimal.csound-score",
                    regex: /\d+/,
                    next: "repeat section before label"
                }
            ],
            "repeat section before label": [
                {
                    token: "empty",
                    regex: /$/,
                    next: "start"
                },
                this.comments,
                {
                    token: "entity.name.label.csound-score",
                    regex: /[A-Z_a-z]\w*/,
                    next: "start"
                }
            ],

            "quoted string": [
                this.popRule({
                    token: "punctuation.definition.string.end.csound-score",
                    regex: /"/
                }),
                this.quotedStringContents,
                {
                    defaultToken: "string.quoted.csound-score"
                }
            ],

            "loop after left brace": [
                this.popRule({
                    token: "constant.numeric.integer.decimal.csound-score",
                    regex: /\d+/,
                    next: "loop after repeat count"
                }),
                this.comments,
                {
                    token: "invalid.illegal.csound",
                    regex: /\S.*/
                }
            ],
            "loop after repeat count": [
                this.popRule({
                    token: "entity.name.function.preprocessor.csound-score",
                    regex: /[A-Z_a-z]\w*\b/,
                    next: "loop after macro name"
                }),
                this.comments,
                {
                    token: "invalid.illegal.csound",
                    regex: /\S.*/
                }
            ],
            "loop after macro name": [
                start,
                this.popRule({
                    token: "punctuation.braced-loop.end.csound-score",
                    regex: /}/
                })
            ]
        });

        this.normalizeRules();
    };

    oop.inherits(CsoundScoreHighlightRules, CsoundPreprocessorHighlightRules);

    exports.CsoundScoreHighlightRules = CsoundScoreHighlightRules;
});

define("ace/mode/csound_score", ["require", "exports", "module", "ace/lib/oop", "ace/mode/text", "ace/mode/csound_score_highlight_rules"], function (require, exports, module) {
    "use strict";

    var oop = require("../lib/oop");
    var TextMode = require("./text").Mode;
    var CsoundScoreHighlightRules = require("./csound_score_highlight_rules").CsoundScoreHighlightRules;

    var Mode = function () {
        this.HighlightRules = CsoundScoreHighlightRules;
    };
    oop.inherits(Mode, TextMode);

    (function () {

        this.lineCommentStart = ";";
        this.blockComment = {start: "/*", end: "*/"};

    }).call(Mode.prototype);

    exports.Mode = Mode;
});
